home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / µSim 1.1 / FabLibsƒ / MovableModal.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-30  |  15.3 KB  |  576 lines  |  [TEXT/CWIE]
  1. #include    <Limits.h>
  2. #include    "UtilsSys7.h"
  3. #include    "FabWList.h"
  4. #include    "Independents.h"
  5. #include    "MovableModal.h"
  6.  
  7. static void DoMovableModalDrag(WindowRef w, Point p);
  8. static void getDragRectMovMod(WindowRef w, RectPtr r);
  9.  
  10. //static Handle    sControlItemList = nil;
  11. //static short    sDefaultItem = 0, sCancelItem = 0;
  12.  
  13. #define    FabSetDialogDefaultItem(d, i)    lDefaultItem = i
  14. #define    FabSetDialogCancelItem(d, i)    lCancelItem = i
  15.  
  16. short HandleMovableModalDialog(/*ModalFilterProcPtr filterProc,*/
  17.                     dialogItemsPtr things,
  18.                     PointPtr    dialogTopLeft,
  19.                     Boolean (*canAcceptDrag)(const HFSFlavor *),
  20.                     OSErr (*dialogDragReaction)(WindowRef, const HFSFlavor *),
  21.                     void (*initProc)(DialogPtr),
  22.                     void (*cleanupProc)(DialogPtr),
  23.                     void (*userProc)(DialogPtr, Handle, short),
  24.                     void (*AdjustMenus)(TEHandle),
  25.                     void (*Handle_My_Menu)(long),
  26.                     void (*DomyKeyEvent)(EventRecord *),
  27.                     Boolean (*PreProcessKeyDown)(EventRecord *, DialogPtr),
  28.                     void (*PostProcessKeyDown)(EventRecord *, DialogPtr),
  29.                     void (*DoUpdate)(EventRecord *),
  30.                     void (*DoActivate)(EventRecord *),
  31.                     void (*DoHiLevEvent)(EventRecord *),
  32.                     void (*DoOSEvent)(EventRecord *),
  33.                     void (*DoIdle)(void),
  34.                     unsigned long minimumSleep,
  35.                     short resId)
  36. {
  37. EventRecord    lMyEvent;
  38. Rect    box;
  39. Handle    item;
  40. Handle    lControlItemList = nil;
  41. GrafPtr    port;
  42. long    myRefCon;
  43. DialogRef    dPtr;
  44. DialogRef    dSelPtr;
  45. WindowRef    w;
  46. FabWindowPtr    thefabw;
  47. UInt32    movablemodalSleep;
  48. dialogItemsPtr    spanPtr;
  49. dialogItemsPtr    itemToBeActivated;
  50. RgnHandle    theRgn;
  51. long    menuSelected;
  52. short    wMenu;
  53. short    code, type, theItemHit = memFullErr;
  54. short    theGroup, theFakeItem, lastItemClosingDialog = cancel;
  55. short    theType, iNum;
  56. short    editTextExists = 0;
  57. short    lDefaultItem = 0, lCancelItem = 0;
  58. unsigned char    keypressed;
  59. Boolean    dialoging;
  60.  
  61. InitCursor();
  62.  
  63. dPtr = GetNewDialog(resId, nil, (WindowRef)-1L);
  64. if (dPtr) {
  65.     GetPort(&port);
  66.     SetGrafPortOfDialog(dPtr);
  67.  
  68.     thefabw = AddWindowToList(dPtr);
  69.     SetUpdate(thefabw, DoMovableModelessUpdate);
  70.     SetActivate(thefabw, DimOrBlackenItems);
  71.     SetGetDragRect(thefabw, getDragRectMovMod);
  72.     SetCanIAcceptDrag(thefabw, canAcceptDrag);
  73.     SetDragReaction(thefabw, dialogDragReaction);
  74.     
  75.     if (dialogTopLeft) {
  76.         if (IsOnScreenWeak(*dialogTopLeft))
  77.             MoveWindow(GetDialogWindow(dPtr), dialogTopLeft->h, dialogTopLeft->v, false);
  78.         }
  79.  
  80. //    sDefaultItem = 0;
  81. //    sCancelItem = 0;
  82.     
  83.     spanPtr = things;
  84. //    sControlItemList = NewHandle(0);
  85. //    if (sControlItemList) {
  86.         while (iNum = spanPtr->itemNumber) {
  87.             myRefCon = spanPtr->refCon;
  88.             GetDialogItem(dPtr, iNum, &type, &item, &box);
  89.             theType = type & itemDisable ? type - itemDisable : type;
  90.             switch(theType) {
  91.                 case ctrlItem+btnCtrl:
  92.                         {
  93.                         if (myRefCon == 1L)
  94.                             FabSetDialogDefaultItem(dPtr, iNum)
  95.                             ;
  96.                         else if (myRefCon == 2L)
  97.                             lastItemClosingDialog = iNum;
  98.                         if (iNum == cancel)
  99.                             FabSetDialogCancelItem(dPtr, iNum)
  100.                             ;
  101.                         }
  102.                     SetControlReference((ControlRef)item, (*(ControlHandle)item)->contrlHilite);
  103.                     PtrAndHand(&item, thefabw->cntlList, sizeof item);
  104.                     break;
  105.                 case ctrlItem+chkCtrl:
  106.                 case ctrlItem+radCtrl:
  107.                     if (myRefCon > 0) {
  108.                         SetControlValue((ControlRef)item, 1);
  109.                         if (userProc)
  110.                             userProc(dPtr, item, iNum);
  111.                         }
  112.     /*                else if (myRefCon == 0) {
  113.                         if (userProc)
  114.                             userProc(dPtr, item, iNum);
  115.                         }*/
  116.                     else if (myRefCon < 0)
  117.                         HiliteControl((ControlRef)item, 255);
  118.                     SetControlReference((ControlRef)item, (*(ControlHandle)item)->contrlHilite);
  119.                     PtrAndHand(&item, thefabw->cntlList, sizeof item);
  120.                     break;
  121.                 case ctrlItem+resCtrl:
  122.                     if (myRefCon)
  123.                         SetControlValue((ControlRef)item, myRefCon);
  124.                     SetControlReference((ControlRef)item, (*(ControlHandle)item)->contrlHilite);
  125.                     PtrAndHand(&item, thefabw->cntlList, sizeof item);
  126.                     break;
  127.                 case statText:
  128.                     if (myRefCon)
  129.                         SetDialogItemText(item, (StringPtr)myRefCon);
  130.                     break;
  131.                 case editText:
  132.                     SetDialogItemText(item, (StringPtr)myRefCon);
  133.                     if(editTextExists == 0) {
  134.                         editTextExists = iNum;
  135.                         }
  136.                     if (theRgn = NewRgn()) {
  137.                         RectRgn(theRgn, &box);
  138.                         InstallRgnHandler(thefabw, theRgn, RecalcTextItems, GetCursor(iBeamCursor),
  139.                                 0, 0, iNum);
  140.                         }
  141.                     break;
  142.         //        case iconItem:
  143.         //            break;
  144.         //        case picItem:
  145.         //            break;
  146.                 case userItem:
  147.                     SetDialogItem(dPtr, iNum, type, (Handle)myRefCon, &box);
  148.                     break;
  149.                 }
  150.             spanPtr++;
  151.             }
  152.         item = nil;
  153.         PtrAndHand(&item, thefabw->cntlList, sizeof item);
  154.         if (editTextExists) {
  155.             ResizeObjects(dPtr);
  156.             RecalcGlobalCoords(thefabw);
  157.             (void) EventAvail(0, &lMyEvent);
  158.             RecalcMouseRegion(dPtr, lMyEvent.where);
  159.             movablemodalSleep = GetCaretTime();
  160.             }
  161.         else
  162.             movablemodalSleep = ULONG_MAX;
  163.         if (initProc)
  164.             initProc(dPtr);
  165. //            (void)TEFeatureFlag(teFOutlineHilite, TEBitSet, ((DialogPeek)dPtr)->textH);
  166.         SelectDialogItemText(dPtr, editTextExists, 0, SHRT_MAX);
  167.         ShowWindow(GetDialogWindow(dPtr));
  168.     
  169.         dialoging = true;
  170.         HiliteMenu(0);
  171.         AdjustMenus(GetTEIfVisible(dPtr, editTextExists));
  172.         InvalMenuBar();
  173.         thefabw->defItem = lDefaultItem;
  174.  
  175.         movablemodalSleep = MIN(minimumSleep, movablemodalSleep);
  176.         do {
  177.             if (WaitNextEvent(everyEvent, &lMyEvent, movablemodalSleep, mouseRgn)) {
  178.                 if (IsDialogEvent(&lMyEvent)) {
  179.                     theFakeItem = 0;
  180.                     switch (lMyEvent.what) {
  181.                         //case mouseDown :
  182.                         //    DebugStr("\pMouse Down!");
  183.                         //    break;
  184.                         case keyDown:
  185.                         case autoKey:
  186.                             keypressed = CHARFROMMESSAGE(lMyEvent.message);
  187.                             if (PreProcessKeyDown ? PreProcessKeyDown(&lMyEvent, dPtr) : true) {
  188.                                 if (keypressed == 3) {
  189.                                     theFakeItem = lDefaultItem;
  190.                                     if (theFakeItem == 0)
  191.                                         theFakeItem = ok;
  192.                                     }
  193.                                 else if (keypressed == 13 && lDefaultItem) {
  194.                                     theFakeItem = lDefaultItem;
  195.                                     }
  196.                                 else if (CmdPeriodOrEsc(&lMyEvent)) {
  197.                                     theFakeItem = lCancelItem;
  198.                                     }
  199.                                 else if (keypressed == 27) { // clear key
  200.                                     //SelIText(dPtr, ((DialogPeek)dPtr)->editField + 1, 0, SHRT_MAX);
  201.                                     DialogDelete(dPtr);
  202.                                     }
  203.                                 else if ((unsigned short)lMyEvent.message == kHelpKey) {
  204.                                     (void)HMSetBalloons(1 - HMGetBalloons());
  205.                                     //RecalcMouseRegion(dPtr, lMyEvent.where);
  206.                                     }
  207.                                 else if (lMyEvent.modifiers & cmdKey) {
  208.                                     AdjustMenus(GetTEIfVisible(dPtr, editTextExists));
  209.                                     menuSelected = MenuKey(keypressed);
  210.                                     if ((wMenu = HiWord(menuSelected)) && wMenu == kRes_Menu_Edit) {
  211.                                         DoMovableModalMenuEdit(LoWord(menuSelected));
  212.                                         HiliteMenu(0);
  213.                                         }
  214.                                     else
  215.                                         Handle_My_Menu(menuSelected);
  216.                                     }
  217.                                 else
  218.                                     (void) DialogSelect(&lMyEvent, &dSelPtr, &theItemHit);
  219.                                 if (theFakeItem)
  220.                                     FlashButton(dPtr, theFakeItem);
  221.                                 if (PostProcessKeyDown)
  222.                                     PostProcessKeyDown(&lMyEvent, dPtr);
  223.                                 }
  224.                             break;
  225.                         case updateEvt:
  226.                             if ((DialogPtr)lMyEvent.message == dPtr) {
  227.                                 BeginUpdate(GetDialogWindow(dPtr));
  228.                                 DoMovableModelessUpdate(dPtr, lDefaultItem);
  229.                                 EndUpdate(GetDialogWindow(dPtr));
  230.                                 }
  231.                             else
  232.                                 DoUpdate(&lMyEvent);
  233.                             break;
  234.                         case diskEvt:
  235.                             if (HiWrd(lMyEvent.message)) {
  236.                                 InitCursor();
  237.                                 DILoad();
  238.                                 (void)DIBadMount(lMyEvent.where, lMyEvent.message);
  239.                                 DIUnload();
  240.                                 }
  241.                             break;
  242.                         case activateEvt :
  243.                             if (DoActivate)
  244.                                 DoActivate(&lMyEvent);
  245.                             break;
  246.                         case kHighLevelEvent:
  247.                             DoHiLevEvent(&lMyEvent);
  248.                             break;
  249.                         case osEvt :
  250.                             DoOSEvent(&lMyEvent);
  251.                             break;
  252.                         default:
  253.                             if (DialogSelect(&lMyEvent, &dSelPtr, &theItemHit)) {
  254.                                 if (dSelPtr == dPtr && theItemHit) {
  255.                                     theFakeItem = theItemHit;
  256.                                     }
  257.                                 }
  258.                         }
  259.                     if (theFakeItem) {
  260.                         GetDialogItem(dPtr, theFakeItem, &type, &item, &box);
  261.                         switch (type) {
  262.                             case ctrlItem+btnCtrl:
  263.                                 if ((theFakeItem >= ok) && (theFakeItem <= lastItemClosingDialog))
  264.                                     dialoging = false;
  265.                                 else if (userProc)
  266.                                     userProc(dPtr, item, theFakeItem);
  267.                                 break;
  268.                             case ctrlItem+chkCtrl:
  269.                                 SetControlValue((ControlHandle)item, 1 - GetControlValue((ControlHandle)item));
  270.                                 if (userProc)
  271.                                     userProc(dPtr, item, theFakeItem);
  272.                                 break;
  273.                             case ctrlItem+radCtrl:
  274.                                 if (GetControlValue((ControlHandle)item) == 0) {
  275.                                     SetControlValue((ControlHandle)item, 1);
  276.                                     for (spanPtr = things; (++spanPtr)->itemNumber != theFakeItem; )
  277.                                         ;
  278.                                     itemToBeActivated = spanPtr;
  279.                                     for (theGroup = spanPtr->group; (--spanPtr)->group == theGroup; )
  280.                                         ;
  281.                                     while ((++spanPtr)->refCon <= 0L)
  282.                                         ;
  283.                                     GetDialogItem(dPtr, spanPtr->itemNumber, &type, &item, &box);
  284.                                     SetControlValue((ControlHandle)item, 0);
  285.                                     spanPtr->refCon = 0L;
  286.                                     itemToBeActivated->refCon = 1L;
  287.                                     if (userProc)
  288.                                         userProc(dPtr, item, theFakeItem);
  289.                                     }
  290.                                 break;
  291.                             case ctrlItem+resCtrl:
  292.                             case editText:
  293.                             case userItem:
  294.                                 if (userProc)
  295.                                     userProc(dPtr, item, theFakeItem);
  296.                                 break;
  297.                             }
  298.                         }
  299.                     }
  300.                 else switch (lMyEvent.what) {
  301.                     case mouseDown :
  302.                         code = FindWindow(lMyEvent.where, &w);
  303.                         switch (code) {
  304.                             case inMenuBar :
  305.                                 AdjustMenus(GetTEIfVisible(dPtr, editTextExists));
  306.                                 menuSelected = MenuSelect(lMyEvent.where);
  307.                                 if ((wMenu = HiWord(menuSelected)) && wMenu == kRes_Menu_Edit) {
  308.                                     DoMovableModalMenuEdit(LoWord(menuSelected));
  309.                                     HiliteMenu(0);
  310.                                     }
  311.                                 else
  312.                                     Handle_My_Menu(menuSelected);
  313.                                 break;
  314.                             case inSysWindow :
  315.                                 SystemClick(&lMyEvent, w);
  316.                                 AdjustMenus(nil);
  317.                                 break;
  318.                             case inContent :
  319.                                 SysBeep(30);
  320.                                 break;
  321.                             case inDrag :
  322.                                 DoMovableModalDrag(w, lMyEvent.where);
  323.                                 break;
  324.                             case inGoAway :
  325.                                 if (TrackGoAway(w, lMyEvent.where)) {
  326.         
  327.                                     }
  328.                                 break;
  329.     /*                        case inZoomIn :
  330.                             case inZoomOut :
  331.                                 break;
  332.     */                        }
  333.                         break;
  334.                     case keyDown:
  335.                     case autoKey:
  336.                         DomyKeyEvent(&lMyEvent);
  337.                         break;
  338.                     case updateEvt :
  339.                         DoUpdate(&lMyEvent);
  340.                         break;
  341.                     case activateEvt :
  342.                         if (DoActivate)
  343.                             DoActivate(&lMyEvent);
  344.                         break;
  345.                     case kHighLevelEvent:
  346.                         DoHiLevEvent(&lMyEvent);
  347.                         break;
  348.                     case osEvt :
  349.                         DoOSEvent(&lMyEvent);
  350.                         break;
  351.                     }
  352.                 }
  353.             else {
  354.                 if (IsDialogEvent(&lMyEvent))
  355.                     (void) DialogSelect(&lMyEvent, &dSelPtr, &theItemHit);
  356.                 DoIdle();
  357.                 }
  358.             }
  359.         while (dialoging);
  360.     
  361.         if (theFakeItem == ok) {
  362.             spanPtr = things;
  363.             while (iNum = spanPtr->itemNumber) {
  364.                 GetDialogItem(dPtr, iNum, &type, &item, &box);
  365.                 theType = type & itemDisable ? type - itemDisable : type;
  366.                 switch(theType) {
  367.                     case ctrlItem+chkCtrl:
  368.                     case ctrlItem+resCtrl:
  369.                         spanPtr->refCon = GetControlValue((ControlHandle)item);
  370.                         break;
  371.                     case editText:
  372.                         GetDialogItemText(item, (StringPtr)spanPtr->refCon);
  373.                         break;
  374.             //        case iconItem:
  375.             //            break;
  376.             //        case picItem:
  377.             //            break;
  378.             //        case userItem:
  379.             //            break;
  380.                     }
  381.                 spanPtr++;
  382.                 }
  383.             }
  384. //        DisposeHandle(sControlItemList);
  385. //        sControlItemList = nil;
  386.         if (cleanupProc)
  387.             cleanupProc(dPtr);
  388. //        }
  389.     SetGrafPortOfDialog(dPtr);    // because the Drag Manager messes up with the current port
  390.     if (dialogTopLeft) {
  391.         *dialogTopLeft = topLeft(GetWindowPort(GetDialogWindow(dPtr))->portRect);
  392.         LocalToGlobal(dialogTopLeft);
  393.         }
  394.     RemoveWindowFromList(dPtr);
  395.     SAFEDESTROY(DisposeDialog, DialogRef, dPtr, DialogRef)
  396.     SetPort(port);
  397.     AdjustMenus(nil);
  398.     InvalMenuBar();
  399.     }
  400. else
  401.     SysBeep(30);
  402. InitCursor();
  403. return theFakeItem;
  404. }
  405.  
  406. void RecalcTextItems(DialogRef d, RgnBalloonCursPtr theObj)
  407. {
  408. Rect    tempRect;
  409. Handle    item;
  410. short    type;
  411.  
  412. GetDialogItem(d, theObj->itemID, &type, &item, &tempRect);
  413. RectRgn(theObj->zoneLocal, &tempRect);
  414. }
  415.  
  416. void DimOrBlackenItems(EventRecord *passEvt, DialogRef w, Handle controlItemList, short defItem, Boolean active)
  417. {
  418. ControlHandle    itemHandle;
  419. ControlHandle    *scanPtr;
  420. DialogPtr    theDialog;
  421. short    theItemHit;
  422. unsigned char    hiliting;
  423.  
  424. if (controlItemList) {
  425.     HLockHi(controlItemList);
  426.     scanPtr = (ControlHandle *)*controlItemList;
  427.     while (itemHandle = *scanPtr++) {
  428.         if (active)
  429.             hiliting = GetControlReference(itemHandle);
  430.         else {
  431.             SetControlReference(itemHandle, (*itemHandle)->contrlHilite);
  432.             hiliting = 255;
  433.             }
  434.         if (hiliting != (*itemHandle)->contrlHilite) {
  435.             HiliteControl(itemHandle, hiliting);
  436.             ValidRect(&(*itemHandle)->contrlRect);
  437.             }
  438.         }
  439.     HUnlock(controlItemList);
  440.     }
  441. if (defItem)
  442.     OutlineButton(w, defItem);
  443. (void) DialogSelect(passEvt, &theDialog, &theItemHit);
  444. }
  445.  
  446. void DoMovableModalMenuEdit(short theItem)
  447. {
  448. DialogRef    dd;
  449.  
  450. if (SystemEdit(theItem - 1) == false) {
  451.     dd = FrontWindow();
  452.     if (dd && ISDLGWINDOW(dd))
  453.         switch (theItem) {
  454. //        case kMItem_Undo:
  455. //            break;
  456.             case kMItem_Cut:
  457.                 DialogCut(dd);
  458.                 ZeroScrap();
  459.                 (void) TEToScrap();
  460. //                PostEvent(keyDown, kCutKey);
  461.                 break;
  462.             case kMItem_Copy:
  463.                 DialogCopy(dd);
  464.                 ZeroScrap();
  465.                 (void) TEToScrap();
  466. //                PostEvent(keyDown, kCopyKey);
  467.                 break;
  468.             case kMItem_Paste:
  469.                 (void) TEFromScrap();
  470.                 DialogPaste(dd);
  471. //                PostEvent(keyDown, kPasteKey);
  472.                 break;
  473.             case kMItem_Clear:
  474.                 DialogDelete(dd);
  475.                 break;
  476.             case kMItem_Select_All:
  477.                 SelectDialogItemText(dd, ((DialogPeek)dd)->editField + 1, 0, SHRT_MAX);
  478.                 break;
  479.             }
  480.     }
  481. }
  482.  
  483. void DoMovableModalDrag(WindowRef w, Point p)
  484. {
  485. EventRecord    tempEvt;
  486. GrafPtr        savePort;
  487. WindowRef    f;
  488. FabWindowPtr    thefabw;
  489. register void (*theProc)(WindowRef);
  490. //register RectPtr    wStateP;
  491.  
  492. f = FrontWindow();
  493. if (w != f && isMovableModal(f))
  494.     SysBeep(30);
  495. else {
  496.     DragWindow(w, p, &qd.screenBits.bounds);
  497.     GetPort(&savePort);
  498.     SetPortWindowPort(w);
  499.     if (thefabw = GetFabWindowPtr(w)) {
  500.         theProc = thefabw->dragProc;
  501.         if (theProc)
  502.             theProc(w);
  503.         RecalcGlobalCoords(thefabw);
  504.         }
  505.     (void) EventAvail(0, &tempEvt);
  506.     RecalcMouseRegion(w, tempEvt.where);
  507.     SetPort(savePort);
  508.     }
  509. }
  510.  
  511. void getDragRectMovMod(WindowRef w, RectPtr r)
  512. {
  513. *r = GetWindowPort(w)->portRect;
  514. }
  515.  
  516. void FabHiliteControl(ControlRef theControl, short hiliteState)
  517. {
  518. HiliteControl(theControl, hiliteState);
  519. SetControlReference(theControl, (*theControl)->contrlHilite);
  520. }
  521.  
  522. TEHandle GetTEIfVisible(DialogPtr dPtr, short editTextExists)
  523. {
  524. Rect    tempRect, resultR;
  525. Handle    item;
  526. short    type;
  527. TEHandle    retTE = nil;
  528.  
  529. if (editTextExists && GetDialogKeyboardFocusItem(dPtr) > 0) {
  530.     GetDialogItem(dPtr, GetDialogKeyboardFocusItem(dPtr), &type, &item, &tempRect);
  531.     if (SectRect(&tempRect, &GetWindowPort(GetDialogWindow(dPtr))->portRect, &resultR))
  532.         retTE = ((DialogPeek)dPtr)->textH;
  533.     }
  534. return retTE;
  535. }
  536.  
  537. void EnableCutCopyPaste(MenuRef editMenu, TEHandle activeTE,
  538.                         Boolean (*isMemoryAvailable)(UInt32)
  539.                         )
  540. {
  541. long    offset;
  542. UInt32    pastedTextSize;
  543.  
  544. if (activeTE) {
  545.     EnableItem(editMenu, kMItem_Select_All);
  546.     if ( (*activeTE)->selStart < (*activeTE)->selEnd ) {
  547.         EnableItem(editMenu, kMItem_Cut);
  548.         EnableItem(editMenu, kMItem_Copy);
  549.         EnableItem(editMenu, kMItem_Clear);
  550.         }
  551.     else {
  552.         DisableItem(editMenu, kMItem_Cut);
  553.         DisableItem(editMenu, kMItem_Copy);
  554.         DisableItem(editMenu, kMItem_Clear);
  555.         }
  556.     pastedTextSize = GetScrap(nil, 'TEXT', &offset);
  557.     if (pastedTextSize > 0 && (isMemoryAvailable ? isMemoryAvailable(pastedTextSize) : true))
  558.         EnableItem(editMenu, kMItem_Paste);
  559.     else
  560.         DisableItem(editMenu, kMItem_Paste);
  561.     }
  562. else {
  563.     DisableCutCopyPaste(editMenu);
  564.     }
  565. }
  566.  
  567. void DisableCutCopyPaste(MenuRef editMenu)
  568. {
  569. short    i;
  570.  
  571. DisableItem(editMenu, kMItem_Undo);
  572. for (i = kMItem_Cut; i <= kMItem_Select_All; i++)
  573.     DisableItem(editMenu, i);
  574. }
  575.  
  576.